/**
 * 题目生成器接口
 * @param difficulty 题目难度级别
 * @returns 返回包含题目内容、解答、难度、知识点编码和题型信息的对象
 */
interface QuestionGenerator {
  (difficulty?: number): {
    content: string;      // 题目内容
    solution: string;     // 题目解答
    difficulty: number;   // 难度级别(1-5)
    knowledge_code: string; // 知识点编码
    question_type: string;  // 题型标识
  };
}

// 题目生成器映射表，key为题型ID，value为对应的生成函数
const questionGenerators: Record<string, QuestionGenerator> = {
  // 题目1：大数改写和四舍五入
  '1': (difficulty = 1) => {
    // 随机生成万级或亿级大数
    const isBillion = Math.random() > 0.5;
    // 这个baseNum要生成的是1——100之间的2位或者3位小数。例如说是12.34或者12.345 或1.20 这样的。
    const baseNum = Number((Math.random() * 99 + 1).toFixed(Math.random() > 0.5 ? 2 : 3)); // 随机生成1-100之间的2位或3位小数
    console.log(baseNum, typeof baseNum);
    const num = isBillion ? baseNum * 100000000 : baseNum * 10000;
    
    // 生成题目和答案
    const unit = isBillion ? '亿' : '万';
    const decimalNum = baseNum;
    // 这里的保留几位应该根据生成的数baseNum的小数数位多少来判断。例如说生成的是12.796，可以保留整数，一位小数，两位小数这样。如果生成的是13.25，那么可以保留整数和一位小数。根据小数数位的长度来判断。
    const decimalLength = baseNum.toString().split('.')[1]?.length || 0;
    
    // 根据小数位数随机决定保留几位小数
    let roundedNum;
    if (decimalLength === 3) {
      const randomChoice = Math.floor(Math.random() * 3); // 0,1,2
      roundedNum = Number(baseNum).toFixed(randomChoice); // 保留0-2位小数
    } else if (decimalLength === 2) {
      const randomChoice = Math.floor(Math.random() * 2); // 0,1
      roundedNum = Number(baseNum).toFixed(randomChoice); // 保留0-1位小数
    } else {
      roundedNum = Number(baseNum).toFixed(0); // 保留整数
    }
   
    // 根据roundedNum的小数位数动态生成题目描述
    const decimalPlaces = roundedNum.toString().split('.')[1]?.length || 0;
    const roundDescription = decimalPlaces === 0 ? '保留整数' : `保留${decimalPlaces}位小数`;
    
    return {
      content: `${num}，改写成${unit}做单位：_____${unit}，${roundDescription}：______${unit}`,
      solution: `${decimalNum}，${roundedNum}`,
      difficulty: difficulty,
      knowledge_code: '1',
      question_type: '填空题',
    };
    },
    // 题目2: 小数的加减法
    '2': (difficulty = 1) => {
      // 随机生成两个小数10.00-30.00之间的小数。
      const a = Number((Math.random() * 20 + 10).toFixed(2));
      const b = Number((Math.random() * 20 + 10).toFixed(2));
      // 随机选择加减法
      const operator = Math.random() > 0.5 ? '+' : '-';
      // 根据operator来生成题目和答案
      let content, solution;
      if (operator === '+') {
        content = `${a}，${b}，这两个数的和是_______`;
        solution = `${a+b}`;
      } else {
        content = `${a}，${b}，这两个数的差是_______`;
        solution = `${a-b}`;
      }
      return {
        content: `${content}`,
        solution: `${solution}`,
        difficulty: difficulty,
        knowledge_code: '2',
        question_type: '填空题',
      };
    },
    // 小数的估算中最大的数和最小的数是什么？
    // 例如：一个{n=2}位小数，它的近似值是3.1，那么这个小数最大是多少，最小是多少？（n可以是2，3）
    // 答案：最大是3.14，最小是3.05，原理最大的是3.1 + 0.04，最小的是3.1-0.05.
    '3': (difficulty = 1) => {
      // 随机生成一个2位或者3位小数
      const n = Math.random() > 0.5 ? 2 : 3;
      const a = Number((Math.random() * 90 + 10).toFixed(n));
      // 随机生成一个0.1-0.9之间的小数
      const b = Number((Math.random() * 9 + 1).toFixed(1));
      // 生成题目和答案
      const content = `${a}，它的近似值是${b}，那么这个小数最大是_______，最小是_______`;
      const solution = `最大是${a+b}，最小是${a-b}`;
      // 答案：最大是3.14，最小是3.05
      return {
        content: `${content}`,
        solution: `${solution}`,
        difficulty: difficulty,
        knowledge_code: '3',
        question_type: '填空题',
      };
    },
    



  };


// 错题记录表，key为学生ID，value为该学生的错题数组
const wrongQuestions: Record<string, any[]> = {};

/**
 * 生成考试题目
 * @param typeId 题型ID
 * @param difficulty 题目难度
 * @returns 返回生成的题目对象
 * @throws 当题型ID无效时抛出错误
 */
export function generateExamQuestion(typeId: string, difficulty: number) {
  const generator = questionGenerators[typeId];
  if (!generator) throw new Error('Invalid question type');
  return generator(difficulty);
}

/**
 * 记录错题
 * @param studentId 学生ID
 * @param question 错题对象
 */
export function recordWrongQuestion(studentId: string, question: any) {
  if (!wrongQuestions[studentId]) {
    wrongQuestions[studentId] = [];
  }
  wrongQuestions[studentId].push(question);
}

/**
 * 获取学生的错题列表
 * @param studentId 学生ID
 * @returns 返回该学生的错题数组，若无错题则返回空数组
 */
export function getWrongQuestions(studentId: string) {
  return wrongQuestions[studentId] || [];
}

/**
 * 从错题中随机生成一道题目
 * @param studentId 学生ID
 * @returns 返回基于错题生成的题目对象，若无错题则返回null
 */
export function generateFromWrongQuestions(studentId: string) {
  const wrongs = getWrongQuestions(studentId);
  if (wrongs.length === 0) return null;
  
  // 随机选择一道错题
  const randomIndex = Math.floor(Math.random() * wrongs.length);
  const wrong = wrongs[randomIndex];
  
  // 返回错题并标记为复习题目
  return {
    ...wrong,
    knowledge_code: wrong.knowledge_code + '_review'
  };
}